package icu.cqcai.xinsi.controller;

import icu.cqcai.xinsi.service.CozeWorkflowService;
import icu.cqcai.xinsi.service.CozeWorkflowService.JobSearchRequest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 职位搜索控制器 - AI智能职位搜索系统
 * 
 * 主要功能：
 * 1. AI职位搜索 - 基于用户条件智能匹配职位
 * 2. 搜索条件管理 - 支持多维度筛选条件
 * 3. 搜索结果展示 - 结构化展示职位信息
 * 4. 快速搜索 - 简化参数的快捷搜索
 * 5. 枚举选项管理 - 提供标准化的选择项
 * 
 * 技术特点：
 * - 集成扣子(Coze) AI工作流，实现智能职位匹配
 * - 支持多种搜索模式（完整搜索、快速搜索）
 * - 标准化的枚举选项管理
 * - 响应式的API接口设计
 * - 完整的参数验证和错误处理
 * 
 * 搜索维度：
 * - 职位名称和技能要求
 * - 工作地点和薪资范围
 * - 工作经验和学历要求
 * - 公司类型和规模
 * 
 * 业务流程：
 * 用户输入搜索条件 → AI工作流处理 → 职位匹配 → 结果展示
 * 
 * @author xinsi团队
 * @version 1.0
 * @since 2024
 */
@Controller
@RequestMapping("/job")
public class JobSearchController {

    /**
     * 日志记录器 - 用于记录搜索过程和结果
     */
    private static final Logger logger = LoggerFactory.getLogger(JobSearchController.class);

    /**
     * 扣子工作流服务 - 核心的AI职位搜索服务
     * 负责调用AI工作流进行智能职位匹配
     */
    @Autowired
    private CozeWorkflowService cozeWorkflowService;

    /**
     * 显示职位搜索页面
     * 
     * 页面功能：
     * 1. 展示职位搜索表单界面
     * 2. 提供所有搜索条件的选择项
     * 3. 加载枚举数据供用户选择
     * 4. 支持高级搜索条件设置
     * 
     * 数据准备：
     * - 工作经验选项（无经验到10年以上）
     * - 学历要求选项（不限到博士）
     * - 公司类型选项（国企、外企、民营等）
     * 
     * @param model Spring MVC模型，用于向页面传递数据
     * @return String 职位搜索页面模板名称
     */
    @GetMapping("/search")
    public String searchPage(Model model) {
        // ========== 添加枚举数据到模型 ==========
        // 为前端页面提供标准化的选择项数据
        model.addAttribute("workExperienceOptions", CozeWorkflowService.WorkExperience.values());
        model.addAttribute("educationOptions", CozeWorkflowService.Education.values());
        model.addAttribute("companyTypeOptions", CozeWorkflowService.CompanyType.values());
        
        return "job-search";
    }

    /**
     * 执行职位搜索 - 核心API接口
     * 
     * 核心功能：
     * 1. 接收用户的搜索条件
     * 2. 验证搜索参数的完整性和有效性
     * 3. 调用AI工作流进行智能职位匹配
     * 4. 返回结构化的职位搜索结果
     * 
     * 搜索逻辑：
     * - 必填字段验证（职位名称、城市、经验、学历）
     * - 可选字段处理（薪资、公司名称、公司类型）
     * - AI工作流调用和结果解析
     * - 搜索结果的格式化和统计
     * 
     * 错误处理：
     * - 参数验证失败的友好提示
     * - AI服务异常的容错处理
     * - 详细的错误日志记录
     * 
     * @param request 职位搜索请求对象，包含所有搜索条件
     *                - jobName: 职位名称（必填）
     *                - city: 工作城市（必填）
     *                - workExperience: 工作经验要求（必填）
     *                - education: 学历要求（必填）
     *                - salaryMin: 最低薪资（可选）
     *                - companyName: 公司名称（可选）
     *                - companyType: 公司类型（可选）
     * @return ResponseEntity 包含搜索结果和状态信息的响应
     */
    @PostMapping("/api/search")
    @ResponseBody
    public ResponseEntity<Map<String, Object>> searchJobs(@RequestBody JobSearchRequest request) {
        Map<String, Object> response = new HashMap<>();
        
        try {
            logger.info("收到职位搜索请求: {}", request);
            
            // ========== 参数验证 ==========
            // 验证职位名称
            if (request.getJobName() == null || request.getJobName().trim().isEmpty()) {
                response.put("success", false);
                response.put("message", "职位名称不能为空");
                return ResponseEntity.badRequest().body(response);
            }
            
            // 验证工作城市
            if (request.getCity() == null || request.getCity().trim().isEmpty()) {
                response.put("success", false);
                response.put("message", "城市不能为空");
                return ResponseEntity.badRequest().body(response);
            }
            
            // 验证工作经验
            if (request.getWorkExperience() == null) {
                response.put("success", false);
                response.put("message", "工作经验不能为空");
                return ResponseEntity.badRequest().body(response);
            }
            
            // 验证学历要求
            if (request.getEducation() == null) {
                response.put("success", false);
                response.put("message", "学历要求不能为空");
                return ResponseEntity.badRequest().body(response);
            }
            
            // ========== 调用AI工作流搜索职位 ==========
            List<Map<String, Object>> jobs = cozeWorkflowService.searchJobs(request);
            
            // ========== 构建成功响应 ==========
            response.put("success", true);
            response.put("message", "搜索成功");
            response.put("data", jobs);
            response.put("total", jobs.size());
            
            logger.info("职位搜索成功，返回 {} 个职位", jobs.size());
            // 展示得到的职位详情（用于调试）
            logger.info("职位搜索结果: {}", jobs);
            return ResponseEntity.ok(response);
            
        } catch (Exception e) {
            // ========== 异常处理 ==========
            logger.error("职位搜索失败", e);
            response.put("success", false);
            response.put("message", "搜索失败: " + e.getMessage());
            return ResponseEntity.internalServerError().body(response);
        }
    }

    /**
     * 快速搜索 - 简化参数的便捷搜索接口
     * 
     * 功能特点：
     * 1. 简化的参数传递方式（URL参数）
     * 2. 提供默认值减少必填项
     * 3. 适合快速搜索和外部调用
     * 4. 内部复用完整搜索逻辑
     * 
     * 默认设置：
     * - 工作经验默认为"不限"
     * - 学历要求默认为"不限"
     * - 可选参数自动处理
     * 
     * 使用场景：
     * - 首页快速搜索框
     * - 移动端简化搜索
     * - 第三方接口调用
     * 
     * @param jobName 职位名称（必填）
     * @param city 工作城市（必填）
     * @param workExperience 工作经验代码，默认1（不限）
     * @param education 学历代码，默认1（不限）
     * @param salaryMin 最低薪资（可选）
     * @param companyName 公司名称（可选）
     * @return ResponseEntity 搜索结果响应，格式与完整搜索相同
     */
    @PostMapping("/api/quick-search")
    @ResponseBody
    public ResponseEntity<Map<String, Object>> quickSearch(
            @RequestParam String jobName,
            @RequestParam String city,
            @RequestParam(defaultValue = "1") Integer workExperience,
            @RequestParam(defaultValue = "1") Integer education,
            @RequestParam(required = false) Integer salaryMin,
            @RequestParam(required = false) String companyName) {
        
        // ========== 构建标准搜索请求 ==========
        // 将简化参数转换为完整的搜索请求对象
        JobSearchRequest request = new JobSearchRequest(jobName, city, workExperience, education);
        request.setSalaryMin(salaryMin);
        request.setCompanyName(companyName);
        
        // 复用完整搜索逻辑
        return searchJobs(request);
    }

    /**
     * 获取枚举选项 - 提供标准化选择项的API接口
     * 
     * 功能说明：
     * 1. 返回所有搜索条件的可选值
     * 2. 提供标准化的代码-描述映射
     * 3. 支持前端动态加载选项
     * 4. 确保数据的一致性和准确性
     * 
     * 返回数据：
     * - 工作经验选项（代码和描述）
     * - 学历要求选项（代码和描述）
     * - 公司类型选项（代码和描述）
     * 
     * 数据格式：
     * ```json
     * {
     *   "workExperience": {"1": "不限", "2": "1年以下", ...},
     *   "education": {"1": "不限", "2": "初中及以下", ...},
     *   "companyType": {"1": "国企", "2": "外商独资", ...}
     * }
     * ```
     * 
     * @return ResponseEntity 包含所有枚举选项的响应数据
     */
    @GetMapping("/api/options")
    @ResponseBody
    public ResponseEntity<Map<String, Object>> getOptions() {
        Map<String, Object> options = new HashMap<>();
        
        // ========== 工作经验选项 ==========
        Map<Integer, String> workExperienceMap = new HashMap<>();
        for (CozeWorkflowService.WorkExperience exp : CozeWorkflowService.WorkExperience.values()) {
            workExperienceMap.put(exp.getCode(), exp.getDescription());
        }
        options.put("workExperience", workExperienceMap);
        
        // ========== 学历选项 ==========
        Map<Integer, String> educationMap = new HashMap<>();
        for (CozeWorkflowService.Education edu : CozeWorkflowService.Education.values()) {
            educationMap.put(edu.getCode(), edu.getDescription());
        }
        options.put("education", educationMap);
        
        // ========== 公司类型选项 ==========
        Map<Integer, String> companyTypeMap = new HashMap<>();
        for (CozeWorkflowService.CompanyType type : CozeWorkflowService.CompanyType.values()) {
            companyTypeMap.put(type.getCode(), type.getDescription());
        }
        options.put("companyType", companyTypeMap);
        
        return ResponseEntity.ok(options);
    }

    /**
     * 处理搜索结果页面 - 服务端渲染的搜索结果展示
     * 
     * 页面功能：
     * 1. 展示职位搜索结果列表
     * 2. 支持URL参数传递搜索条件
     * 3. 服务端执行搜索并渲染结果
     * 4. 提供搜索条件的回显功能
     * 
     * 处理逻辑：
     * - 从URL参数获取搜索条件
     * - 验证参数完整性
     * - 执行搜索并处理结果
     * - 将结果和条件传递给页面
     * 
     * 错误处理：
     * - 搜索失败时显示错误信息
     * - 参数不完整时仅显示搜索表单
     * - 异常情况的友好提示
     * 
     * @param jobName 职位名称（可选）
     * @param city 工作城市（可选）
     * @param workExperience 工作经验代码（可选）
     * @param education 学历代码（可选）
     * @param salaryMin 最低薪资（可选）
     * @param companyName 公司名称（可选）
     * @param model Spring MVC模型，用于向页面传递数据
     * @return String 搜索结果页面模板名称
     */
    @GetMapping("/results")
    public String searchResults(
            @RequestParam(required = false) String jobName,
            @RequestParam(required = false) String city,
            @RequestParam(required = false) Integer workExperience,
            @RequestParam(required = false) Integer education,
            @RequestParam(required = false) Integer salaryMin,
            @RequestParam(required = false) String companyName,
            Model model) {
        
        // ========== 搜索条件回显 ==========
        // 将搜索条件传递给页面，用于表单回显和结果展示
        model.addAttribute("jobName", jobName);
        model.addAttribute("city", city);
        model.addAttribute("workExperience", workExperience);
        model.addAttribute("education", education);
        model.addAttribute("salaryMin", salaryMin);
        model.addAttribute("companyName", companyName);
        
        // ========== 执行搜索 ==========
        // 只有当必要参数都存在时才执行搜索
        if (jobName != null && city != null && workExperience != null && education != null) {
            try {
                // 构建搜索请求
                JobSearchRequest request = new JobSearchRequest(jobName, city, workExperience, education);
                request.setSalaryMin(salaryMin);
                request.setCompanyName(companyName);
                
                // 执行搜索
                List<Map<String, Object>> jobs = cozeWorkflowService.searchJobs(request);
                
                // 将结果传递给页面
                model.addAttribute("jobs", jobs);
                model.addAttribute("total", jobs.size());
                
            } catch (Exception e) {
                // 搜索失败时记录错误并显示错误信息
                logger.error("搜索职位失败", e);
                model.addAttribute("error", "搜索失败: " + e.getMessage());
            }
        }
        
        return "search-results";
    }
} 